#ifndef LOGGER_H
#define LOGGER_H

#include <string>
#include <fstream>
#include <iostream>
#include <mutex>
#include <memory>
#include <vector>
#include <thread>
#include <condition_variable>
#include <queue>
#include <atomic>
#include <chrono>
#include <iomanip>
#include <sstream>
#include <ctime>

namespace common {
namespace logger {

// 日志级别
enum class LogLevel {
    DEBUG,
    INFO,
    WARNING,
    ERROR,
    FATAL
};

// 日志条目
struct LogEntry {
    std::string message;
    LogLevel level;
    std::chrono::system_clock::time_point timestamp;
    std::thread::id threadId;
    
    LogEntry(const std::string& msg, LogLevel lvl)
        : message(msg), level(lvl),
          timestamp(std::chrono::system_clock::now()),
          threadId(std::this_thread::get_id()) {}
};

// 日志输出接口
class LogSink {
public:
    virtual ~LogSink() = default;
    virtual void write(const LogEntry& entry) = 0;
    virtual void flush() = 0;
};

// 控制台日志输出
class ConsoleSink : public LogSink {
public:
    void write(const LogEntry& entry) override;
    void flush() override { std::cout.flush(); }
};

// 文件日志输出
class FileSink : public LogSink {
public:
    FileSink(const std::string& filename);
    ~FileSink();
    
    void write(const LogEntry& entry) override;
    void flush() override;
    
private:
    std::ofstream file_;
    std::mutex fileMutex_;
};

// 日志管理类
class Logger {
public:
    static Logger& getInstance();
    
    // 添加日志接收器
    void addSink(std::shared_ptr<LogSink> sink);
    
    // 设置全局日志级别
    void setLevel(LogLevel level) { level_ = level; }
    
    // 获取当前日志级别
    LogLevel getLevel() const { return level_; }
    
    // 日志记录函数
    void log(LogLevel level, const std::string& message);
    void debug(const std::string& message) { log(LogLevel::DEBUG, message); }
    void info(const std::string& message) { log(LogLevel::INFO, message); }
    void warning(const std::string& message) { log(LogLevel::WARNING, message); }
    void error(const std::string& message) { log(LogLevel::ERROR, message); }
    void fatal(const std::string& message) { log(LogLevel::FATAL, message); }
    
    // 启动异步日志线程
    void startAsync();
    
    // 停止异步日志线程
    void stopAsync();
    
    // 刷新所有输出
    void flushAll();
    
    // 析构函数
    ~Logger();
    
    // 将日志级别转换为字符串
    static std::string levelToString(LogLevel level);
    
    // 格式化时间戳
    static std::string formatTimestamp(const std::chrono::system_clock::time_point& time);
    
private:
    // 私有构造函数
    Logger();
    
    // 异步处理线程函数
    void processLogQueue();

private:
    std::vector<std::shared_ptr<LogSink>> sinks_;  // 日志接收器
    std::mutex sinkMutex_;                        // 保护接收器的互斥锁
    LogLevel level_;                              // 全局日志级别
    
    // 异步日志相关
    std::queue<LogEntry> logQueue_;               // 日志队列
    std::mutex queueMutex_;                       // 队列互斥锁
    std::condition_variable queueCondition_;      // 条件变量
    std::thread asyncThread_;                     // 异步处理线程
    std::atomic<bool> running_;                   // 运行状态标志
};

// 宏定义，方便使用
#define LOG_DEBUG(message) common::logger::Logger::getInstance().debug(message)
#define LOG_INFO(message) common::logger::Logger::getInstance().info(message)
#define LOG_WARNING(message) common::logger::Logger::getInstance().warning(message)
#define LOG_ERROR(message) common::logger::Logger::getInstance().error(message)
#define LOG_FATAL(message) common::logger::Logger::getInstance().fatal(message)

} // namespace logger
} // namespace common

#endif // LOGGER_H 